package uy.com.csi.gestpro.util;

import java.io.*;
import java.util.ArrayList;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

/**
 * 
 * @author ericson
 */
public class Archivo implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	public static final String MIME_IMAGE_JPEG;
	public static final String MIME_DESCONOCIDO;
	public static ZipOutputStream zos;
	public static final String MIME_UNKNOW;

	static {
		MIME_IMAGE_JPEG = "image/jpeg";
		MIME_DESCONOCIDO = "application/octet-stream";
		MIME_UNKNOW = "application/unknown";
	}

	public boolean guardarArchivo(byte[] bit, String ruta) {
		boolean est = false;
		OutputStream out;
		try {
			out = new FileOutputStream(ruta);
			out.write(bit, 0, bit.length);
			out.flush();
			out.close();
			est = true;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return est;
	}

	public boolean copiarArchivo(String destino, String origen) {
		boolean est = false;
		try {
			File inFile = new File(origen);
			File outFile = new File(destino);
			FileInputStream in = new FileInputStream(inFile);
			FileOutputStream out = new FileOutputStream(outFile);
			int c;
			while ((c = in.read()) != -1) {
				out.write(c);
			}
			in.close();
			out.close();
		} catch (IOException e) {
		}
		return est;
	}

	public boolean ifExistFile(String carpeta, String fichero) {
		File file = new File(carpeta + fichero);
		return file.exists();
	}

	public static String obtenerExtension(String archivo) {
		int indexOf = archivo.lastIndexOf(".");
		return archivo.substring(indexOf + 1);
	}

	public byte[] obtenerBytes(InputStream is, int tope) {
		DataInputStream dis = new DataInputStream(is);
		byte[] bytes = new byte[tope];
		try {
			dis.readFully(bytes);
			if (dis != null) {
				dis.close();
				is.close();
			}
		} catch (java.io.IOException ioe) {
			ioe.printStackTrace();
		}
		return bytes;
	}

	public int comprimirArchivo(String path, String extension) {
		try {
			path = path.substring(0, path.length() - 1);
			comprimir(path, extension);
		} catch (Exception e) {
			e.printStackTrace();
			return -1;
		}
		return 1;
	}

	private static void comprimir(String path, String extension) throws IOException, FileNotFoundException {
		File file = new File(path);

		zos = new ZipOutputStream(new FileOutputStream(path + extension));
		recursiveFiles(file);
		zos.close();
	}

	private static void comprimir(String path, String extension, ArrayList<String> names) throws IOException, FileNotFoundException {
		File file = new File(path);

		zos = new ZipOutputStream(new FileOutputStream(path + extension));
		recursiveFiles(file, names);
		zos.close();
	}

	private static void recursiveFiles(File file) throws IOException, FileNotFoundException {
		if (file.isDirectory()) {
			String listaArchivos[] = file.list();
			if (listaArchivos != null) {
				for (int i = 0; i < listaArchivos.length; i++) {
					recursiveFiles(new File(file, listaArchivos[i]));
				}
			}
		} else {
			byte[] buf = new byte[1024];
			int len;
			String nombreArchivo = file.toString().substring(file.toString().lastIndexOf("\\") + 1);
			ZipEntry zipEntry = new ZipEntry(nombreArchivo);
			FileInputStream fin = new FileInputStream(file);
			BufferedInputStream in = new BufferedInputStream(fin);
			zos.putNextEntry(zipEntry);
			while ((len = in.read(buf)) >= 0) {
				zos.write(buf, 0, len);
			}
			in.close();
			zos.closeEntry();
		}
	}

	private static void recursiveFiles(File file, ArrayList<String> nameFiles) throws IOException, FileNotFoundException {
		if (file.isDirectory()) {
			String listaArchivos[] = file.list();
			if (listaArchivos != null) {
				for (int i = 0; i < listaArchivos.length; i++) {
					recursiveFiles(new File(file, listaArchivos[i]), nameFiles);
				}
			}
		} else {
			String nombreArchivo = file.toString().substring(file.toString().lastIndexOf("\\") + 1);
			if (isInnerName(nombreArchivo, nameFiles)) {
				byte[] buf = new byte[1024];
				int len;
				ZipEntry zipEntry = new ZipEntry(nombreArchivo);
				FileInputStream fin = new FileInputStream(file);
				BufferedInputStream in = new BufferedInputStream(fin);
				zos.putNextEntry(zipEntry);
				while ((len = in.read(buf)) >= 0) {
					zos.write(buf, 0, len);
				}
				in.close();
				zos.closeEntry();
			}
		}
	}

	public static boolean isInnerName(String name, ArrayList<String> names) {
		for (String n : names) {
			if (n.equals(name)) {
				return true;
			}
		}
		return false;
	}

	public void guardarArchivo(byte[] data, String path, String fileName) {
		OutputStream out;
		File file = new File(path);
		file.mkdirs();
		try {
			out = new FileOutputStream(path + fileName);
			out.write(data);

			out.flush();
			out.close();
			data = new byte[1];
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public int descomprimirArchivo(String path, String formato) {
		BufferedOutputStream bos = null;
		FileInputStream fis;

		String rutaGuardado = path.substring(0, path.lastIndexOf(formato)) + "\\";
		// Creando la carpeta de descomprimir
		File file = new File(rutaGuardado);
		file.mkdir();

		try {
			fis = new FileInputStream(path);
			ZipInputStream zis = new ZipInputStream(new BufferedInputStream(fis));
			ZipEntry ze;

			while ((ze = zis.getNextEntry()) != null) {
				int count = 0;
				byte data[] = new byte[2048];
				String nombreArchivo = rutaGuardado + ze.getName();
				FileOutputStream fos = new FileOutputStream(nombreArchivo);
				bos = new BufferedOutputStream(fos, 2048);
				while ((count = zis.read(data, 0, 2048)) != -1) {
					bos.write(data, 0, count);
				}
				fos.close();
				bos.close();
			}
			zis.close();
			fis.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			return 0;
		} catch (IOException e) {
			e.printStackTrace();
			return 0;
		}
		return 1;
	}

	public void escribirArchivo(String path, String carpeta, String nombreFichero, String cadena) {
		FileWriter fichero = null;
		PrintWriter pw = null;
		System.out.println("Longitud total de la cadena" + cadena.length());
		try {
			File file = new File(path + carpeta);
			if (file.exists()) {
				fichero = new FileWriter(path + carpeta + nombreFichero, true);
			} else {
				file.mkdirs();
				fichero = new FileWriter(path + carpeta + nombreFichero);
			}
			pw = new PrintWriter(fichero);
			pw.print(cadena);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (fichero != null) {
					fichero.close();
					pw.close();
				}
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
	}

	public void eliminarArchivo(String path) {
		File file = new File(path);
		if (file.exists()) {
			eliminarArchivo(file);
		}
	}

	public boolean eliminarArchivo(File file) {
		if (file.isDirectory()) {
			File[] files = file.listFiles();
			for (int i = 0; i < files.length; i++) {
				eliminarArchivo(files[i]);
			}
		} else {
			return file.delete();
		}
		return file.delete();
	}
}
